package fun_Implement

import (
	"fmt"
	"gitee.com/huanminabc/go-utils/common"
	"go-LineScriptCommand/container"
	"go-LineScriptCommand/global"
	"math"
	rund_ "math/rand"
	"strconv"
	"strings"
)

func init() {
	var funs = []container.Fun{}
	common.InsertSliceBatch(&funs,
		abs,
		ceil,
		floor,
		round,
		_max_,
		_min_,
		avg,
		pow,
		sqrt,
		rand,
		sin,
		asin,
		exp,
		_pi_,
		incr,
		decr,
		sum,
		lose,
		mul,
		div,
		mod,
		toFixed,
		fenToYuan,
		yuanToFen,
	)
	container.RegisterFunList(funs)
	container.RegisterType("math", funs)
}

// 随机数
func rand(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 生成随机数
签名: rand(min,max)
- min 最小值 整数
- max 最大值 整数
示例:
1. rand(1,10) 返回值为 1-10之间的随机数
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 1 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 2 {
		panic("rand函数参数个数不正确")
	}
	//拆分参数
	min_, err := strconv.Atoi(args[0])
	if err != nil {
		panic("rand函数参数必须是整数:" + args[0])
	}
	max_, err := strconv.Atoi(args[1])
	if err != nil {
		panic("rand函数参数必须是整数:" + args[1])
	}
	//返回随机数
	rand_ := min_ + rund_.Intn(max_-min_)
	return strconv.Itoa(rand_)
}

// 绝对值
func abs(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 将数值取绝对值
签名: abs(number)
- number 可以是整数或者浮点数
示例: 
1. abs(-1) 返回值为 1
2. abs(-2.5) 返回值为 2.5
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("abs函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("abs函数参数必须是数值:" + args[0])
	}
	//返回绝对值
	abs_ := math.Abs(parseFloat)
	float := strconv.FormatFloat(abs_, 'f', -1, 64)
	return float
}

func ceil(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 向上取整
签名: ceil(number)
- number 可以是整数或者浮点数
示例:
1. ceil(1.1) 返回值为 2
2. ceil(1.9) 返回值为 2
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("ceil函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("ceil函数参数必须是数值:" + args[0])
	}
	//返回向上取整
	ceil_ := math.Ceil(parseFloat)
	float := strconv.FormatFloat(ceil_, 'f', -1, 64)
	return float
}
func floor(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 向下取整
签名: floor(number)
- number 可以是整数或者浮点数
示例:
1. floor(1.1) 返回值为 1
2. floor(1.9) 返回值为 1
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("floor函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("floor函数参数必须是数值:" + args[0])
	}
	//返回向下取整
	floor_ := math.Floor(parseFloat)
	float := strconv.FormatFloat(floor_, 'f', -1, 64)
	return float
}

func round(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 四舍五入
签名: round(number)
- number 可以是整数或者浮点数
示例:
1. round(1.1) 返回值为 1
2. round(1.9) 返回值为 2
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("round函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("round函数参数必须是数值:" + args[0])
	}
	//返回四舍五入
	round_ := math.Round(parseFloat)
	float := strconv.FormatFloat(round_, 'f', -1, 64)
	return float
}

func _max_(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求最大值
签名: max(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. max(1,2,3) 返回值为 3
2. max(1.1,2.2,3.3) 返回值为 3.3
`
	}
	//如果管道有值,那么就需要处理下,多行和单行情况
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			data = global.RemoveStrSymbol(data)
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("max函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("max函数参数必须是数值:" + arg)
		}
	}

	//拆分参数
	var max_ float64
	for _, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("max函数参数必须是数值:" + arg)
		}
		if max_ < parseFloat {
			max_ = parseFloat
		}
	}
	float := strconv.FormatFloat(max_, 'f', -1, 64)
	return float
}

func _min_(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求最小值
签名: min(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. min(1,2,3) 返回值为 1
2. min(1.1,2.2,3.3) 返回值为 1.1
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("min函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("min函数参数必须是数值:" + arg)
		}
	}

	//拆分参数
	var min_ = math.MaxFloat64
	for _, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("min函数参数必须是数值:" + arg)
		}
		if min_ > parseFloat {
			min_ = parseFloat
		}
	}
	float := strconv.FormatFloat(min_, 'f', -1, 64)
	return float
}

func avg(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求平均值
签名: avg(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. avg(1,2,3) 返回值为 2
2. avg(1.1,2.2,3.3) 返回值为 2.2
`
	}
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("avg函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("avg函数参数必须是数值:" + arg)
		}
	}

	var sum_ float64
	for _, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("avg函数参数必须是数值:" + arg)
		}
		sum_ += parseFloat
	}
	avg_ := sum_ / float64(len(args))
	float := strconv.FormatFloat(avg_, 'f', -1, 64)
	return float
}

func pow(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求次方
签名: pow(number1,number2)
- number1 可以是整数或者浮点数
- number2 可以是整数或者浮点数
示例:	
1. pow(2,3) 返回值为 8
2. pow(2.5,2) 返回值为 6.25
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 1 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 2 {
		panic("pow函数参数个数不正确")
	}
	//拆分参数
	parseFloat1, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("pow函数参数必须是数值:" + args[0])
	}
	parseFloat2, err := strconv.ParseFloat(args[1], 64)
	if err != nil {
		panic("pow函数参数必须是数值:" + args[1])
	}
	//返回次方
	pow_ := math.Pow(parseFloat1, parseFloat2)
	float := strconv.FormatFloat(pow_, 'f', -1, 64)
	return float
}

func sqrt(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求平方根
签名: sqrt(number)
- number 可以是整数或者浮点数
示例:
1. sqrt(4) 返回值为 2
2. sqrt(9) 返回值为 3
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("sqrt函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("sqrt函数参数必须是数值:" + args[0])
	}
	//返回平方根
	sqrt_ := math.Sqrt(parseFloat)
	float := strconv.FormatFloat(sqrt_, 'f', -1, 64)
	return float
}

func sin(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求正弦值
签名: sin(number)
- number 可以是整数或者浮点数
示例:
1. sin(30) 返回值为 0.5
2. sin(45) 返回值为 0.7071067811865475
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("sin函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("sin函数参数必须是数值:" + args[0])
	}
	//返回正弦值
	sin := math.Sin(parseFloat)
	float := strconv.FormatFloat(sin, 'f', -1, 64)
	return float
}
func asin(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求反正弦值
签名: asin(number)
- number 可以是整数或者浮点数
示例:
1. asin(0.5) 返回值为 30
2. asin(0.7071067811865475) 返回值为 45
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("asin函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("asin函数参数必须是数值:" + args[0])
	}
	//返回反正弦值
	asin := math.Asin(parseFloat)
	float := strconv.FormatFloat(asin, 'f', -1, 64)
	return float
}

func exp(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求欧拉数e的参数次幂的值
签名: exp(number)
- number 可以是整数或者浮点数
示例:
1. exp(1) 返回值为 2.718281828459045
2. exp(2) 返回值为 7.3890560989306495
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("exp函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("exp函数参数必须是数值:" + args[0])
	}
	//返回欧拉数e的参数次幂的值
	exp := math.Exp(parseFloat)
	float := strconv.FormatFloat(exp, 'f', -1, 64)
	return float
}

func _pi_(args ...string) string {
	//判断第一个参数是-doc
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 圆周率
签名: pi() 或者pi
示例:
1. pi 返回值为 3.141592653589793
`
	}
	if len(args) != 0 {
		panic("pi函数不需要参数")
	}
	//返回圆周率
	pi := math.Pi
	//返回结果到管道中
	float := strconv.FormatFloat(pi, 'f', -1, 64)
	return float
}
func incr(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 加n
签名: incr(number1,n)
- number 可以是整数或者浮点数
- n 可以是整数或者浮点数 默认是1 (可以不写)
示例:
1. incr(1) 返回值为 2
2. incr(1,2) 返回值为 3
`
	}

	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) < 2 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	//如果参数是1个,那么默认是1
	if len(args) == 1 {
		args = append(args, "1")
	}

	if len(args) != 2 {
		panic("incr函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("incr函数参数必须是数值:" + args[0])
	}
	parseFloat2, err := strconv.ParseFloat(args[1], 64)
	if err != nil {
		panic("incr函数参数必须是数值:" + args[1])
	}
	//返回结果到管道中
	float := strconv.FormatFloat(parseFloat+parseFloat2, 'f', -1, 64)
	return float
}

func decr(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 减n
签名: decr(number1,n)
- number 可以是整数或者浮点数
- n 可以是整数或者浮点数 默认是1 (可以不写)
示例:
1. decr(1) 返回值为 0
2. decr(1,2) 返回值为 -1
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) < 2 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	//如果参数是1个,那么默认是1
	if len(args) == 1 {
		args = append(args, "1")
	}
	if len(args) != 2 {
		panic("decr函数参数个数不正确")
	}
	//拆分参数
	parseFloat, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("decr函数参数必须是数值:" + args[0])
	}
	parseFloat2, err := strconv.ParseFloat(args[1], 64)
	if err != nil {
		panic("decr函数参数必须是数值:" + args[1])
	}
	//返回结果到管道中
	float := strconv.FormatFloat(parseFloat-parseFloat2, 'f', -1, 64)
	return float
}

func sum(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求和
签名: sum(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. sum(1,2,3) 返回值为 6
2. sum(1.1,2.2,3.3) 返回值为 6.6
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("sum函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("sum函数参数必须是数值:" + arg)
		}
	}
	//拆分参数
	var sum float64
	for _, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("sum函数参数必须是数值:" + arg)
		}
		sum += parseFloat
	}
	//返回结果到管道中
	float := strconv.FormatFloat(sum, 'f', -1, 64)
	return float
}

func lose(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求差
签名: lose(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. lose(1,2,3) 返回值为 -4
2. lose(1.1,2.2,3.3) 返回值为 -4.4
`
	}
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("lose函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("lose函数参数必须是数值:" + arg)
		}
	}
	var sum_ float64
	for i, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("lose函数参数必须是数值:" + arg)
		}
		if i == 0 {
			sum_ = parseFloat
		} else {
			sum_ -= parseFloat
		}
	}
	float := strconv.FormatFloat(sum_, 'f', -1, 64)
	return float
}

func mul(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求积
签名: mul(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. mul(1,2,3) 返回值为 6
2. mul(1.1,2.2,3.3) 返回值为 7.986
`
	}
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("mul函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("mul函数参数必须是数值:" + arg)
		}
	}

	var sum float64
	for i, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("mul函数参数必须是数值:" + arg)
		}
		if i == 0 {
			sum = parseFloat
		} else {
			sum *= parseFloat
		}
	}
	float := strconv.FormatFloat(sum, 'f', -1, 64)
	return float
}

func div(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求商
签名: div(number1,number2,...)
- number 可以是整数或者浮点数
示例:
1. div(1,2,3) 返回值为 0.16666666666666666
2. div(1.1,2.2,3.3) 返回值为 0.16666666666666666
`
	}
	if container.GetPrePipelineData().Data != "" {
		data := container.GetPrePipelineData().Data
		//判断是否有分隔符,如果有分隔符,那么就拆分
		if strings.Contains(data, global.LineBreak) {
			args1 := strings.Split(data, global.LineBreak)
			args = append(args1, args...) //将管道的数据放到函数的第一个参数
		} else {
			container.GetPrePipelineDataAndData(&args)
		}
	}
	if len(args) < 2 {
		panic("div函数参数个数不正确")
	}
	//判断args是否都是数值
	for _, arg := range args {
		if !common.IsNumber(arg) {
			panic("div函数参数必须是数值:" + arg)
		}
	}
	var sum float64
	for i, arg := range args {
		parseFloat, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			panic("div函数参数必须是数值:" + arg)
		}
		if i == 0 {
			sum = parseFloat
		} else {
			//除数不能为0
			if parseFloat == 0 {
				panic("第" + strconv.Itoa(i+1) + "位除数不能为0")
			}
			sum /= parseFloat
		}
	}
	float := strconv.FormatFloat(sum, 'f', -1, 64)
	return float
}

// 取余
func mod(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 求余数
签名: mod(number1,number2)
- number1 可以是整数或者浮点数
- number2 可以是整数或者浮点数
示例:
1. mod(5,2) 返回值为 1
2. mod(5.5,2) 返回值为 1.5
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 1 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 2 {
		panic("mod函数参数个数不正确")
	}
	//拆分参数
	parseFloat1, err := strconv.ParseFloat(args[0], 64)
	if err != nil {
		panic("mod函数参数必须是数值:" + args[0])
	}
	parseFloat2, err := strconv.ParseFloat(args[1], 64)
	if err != nil {
		panic("mod函数参数必须是数值:" + args[1])
	}
	//返回余数
	mod_ := math.Mod(parseFloat1, parseFloat2)
	//返回结果到管道中
	float := strconv.FormatFloat(mod_, 'f', -1, 64)
	return float
}

// 小数浮点处理
func toFixed(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 小数浮点处理
签名: toFixed(浮点小数,保留位数)
- 保留位数: 保留几位小数
示例:
1. toFixed(1.123456,2) 返回值为 1.12
2. toFixed(1.123456,3) 返回值为 1.123
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 1 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 2 {
		panic("toFixed函数参数个数不正确")
	}
	//拆分参数
	arg1 := args[0]
	arg2 := args[1]
	parseFloat1, err := strconv.ParseFloat(arg1, 64)
	if err != nil {
		panic("toFixed函数参数必须是数值:" + arg1)
	}
	_, err = strconv.Atoi(arg2)
	if err != nil {
		panic("toFixed函数参数必须是整数:" + arg2)
	}
	//保留几位小数
	res := fmt.Sprintf("%."+arg2+"f", parseFloat1)
	return res
}

// 元转分
func yuanToFen(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 元转分
签名: yuanToFen(元)
- 元:  1000.00
示例:
1. yuanToFen(1000.00) 返回值为 100000
`
	}
	//如果管道有值,那么就将前一个管道的值给函数第一个
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("yuanToFen函数参数个数不正确")
	}
	//拆分参数
	arg1 := args[0]
	//判断是否是小数
	if !common.IsDecimal(arg1) {
		panic("yuanToFen函数参数必须是小数:" + arg1)
	}
	//转换为分
	float, err := strconv.ParseFloat(arg1, 64)
	if err != nil {
		panic("yuanToFen函数参数必须是数值:" + arg1)
	}
	res := common.YuanToFen(float)
	toString := common.Int64ToString(res)
	return toString
}

func fenToYuan(args ...string) string {
	if len(args) > 0 && args[0] == "-doc" {
		return `
功能: 分转元
签名: fenToYuan(分)
- 分:  100000 
示例:
1. fenToYuan(100000) 返回值为 1000.00
`
	}
	if len(args) == 0 && container.GetPrePipelineData().Data != "" {
		container.GetPrePipelineDataAndData(&args)
	}
	if len(args) != 1 {
		panic("fenToYuan函数参数个数不正确")
	}
	arg1 := args[0]
	if !common.IsNumber(arg1) {
		panic("fenToYuan函数参数必须是整数:" + arg1)
	}
	//转换为元
	int_ := common.StringToInt64(arg1)
	res := common.FenToYuan(int_)
	//返回结果到管道中
	toString := fmt.Sprintf("%.2f", res)
	return toString
}
